/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package co.com.claro.administracionSolicitudes.db;

import co.com.claro.administracionSolicitudes.dao.AplicacionJpaController;
import co.com.claro.administracionSolicitudes.dao.CargoJpaController;
import co.com.claro.administracionSolicitudes.dao.CertificacionUsuarioJpaController;
import co.com.claro.administracionSolicitudes.dao.CiudadJpaController;
import co.com.claro.administracionSolicitudes.dao.CoordinacionJpaController;
import co.com.claro.administracionSolicitudes.dao.EmpresaJpaController;
import co.com.claro.administracionSolicitudes.dao.GerenciaJpaController;
import co.com.claro.administracionSolicitudes.dao.ParametrosPasswordJpaController;
import co.com.claro.administracionSolicitudes.dao.PerfilJpaController;
import co.com.claro.administracionSolicitudes.dao.PrivilegioSolicitudJpaController;
import co.com.claro.administracionSolicitudes.dao.SolicitudJpaController;
import co.com.claro.administracionSolicitudes.dao.TipoAplicacionJpaController;
import co.com.claro.administracionSolicitudes.dao.TipoCompaniaJpaController;
import co.com.claro.administracionSolicitudes.dao.TipoDocumentoJpaController;
import co.com.claro.administracionSolicitudes.dao.TipoEmpleadoJpaController;
import co.com.claro.administracionSolicitudes.dao.TipoUsuarioJpaController;
import co.com.claro.administracionSolicitudes.dao.UsuarioJpaController;
import co.com.claro.administracionSolicitudes.dao.UsuarioTemporalJpaController;
import co.com.claro.administracionSolicitudes.dao.UsuariosPorAplicacionesJpaController;
import co.com.claro.administracionSolicitudes.dao.exceptions.ClaroException;
import co.com.claro.administracionSolicitudes.dao.exceptions.NonexistentEntityException;
import co.com.claro.administracionSolicitudes.dao.exceptions.RollbackFailureException;
import co.com.claro.administracionSolicitudes.dto.PrivilegioSolicitudDto;
import co.com.claro.administracionSolicitudes.dto.SolicitudDto;
import co.com.claro.administracionSolicitudes.dto.UsuarioDto;
import co.com.claro.administracionSolicitudes.entity.Aplicacion;
import co.com.claro.administracionSolicitudes.entity.Cargo;
import co.com.claro.administracionSolicitudes.entity.CertificacionUsuario;
import co.com.claro.administracionSolicitudes.entity.Ciudad;
import co.com.claro.administracionSolicitudes.entity.Coordinacion;
import co.com.claro.administracionSolicitudes.entity.Empresa;
import co.com.claro.administracionSolicitudes.entity.Gerencia;
import co.com.claro.administracionSolicitudes.entity.ParametrosPassword;
import co.com.claro.administracionSolicitudes.entity.Perfil;
import co.com.claro.administracionSolicitudes.entity.PrivilegioSolicitud;
import co.com.claro.administracionSolicitudes.entity.Solicitud;
import co.com.claro.administracionSolicitudes.entity.TipoAplicacion;
import co.com.claro.administracionSolicitudes.entity.TipoCompania;
import co.com.claro.administracionSolicitudes.entity.TipoDocumento;
import co.com.claro.administracionSolicitudes.entity.TipoEmpleado;
import co.com.claro.administracionSolicitudes.entity.TipoUsuario;
import co.com.claro.administracionSolicitudes.entity.Usuario;
import co.com.claro.administracionSolicitudes.entity.UsuarioTemporal;
import co.com.claro.administracionSolicitudes.entity.UsuariosPorAplicaciones;
import co.com.claro.administracionSolicitudes.entity.enums.EstadoActividadEnum;
import co.com.claro.administracionSolicitudes.entity.enums.EstadosSolicitudEnum;
import co.com.claro.administracionSolicitudes.seguridad.EJBSeguridadLocal;
import java.util.List;
import javax.ejb.EJB;
import javax.ejb.Stateless;
import javax.inject.Inject;

/**
 *
 * @author USUARIO
 */
@Stateless
public class EJBDatabaseSolicitudes implements EJBDatabaseSolicitudesLocal {

    //--------------------------------------------------------------------------
    //Controladores
    //--------------------------------------------------------------------------
    @EJB
    private EJBSeguridadLocal localSeguridad;
    //--------------------------------------------------------------------------
    //Controladores
    //--------------------------------------------------------------------------

    @Inject
    private EmpresaJpaController empresaJpa;
    @Inject
    private TipoAplicacionJpaController tipoAplicacionJpa;
    @Inject
    private TipoDocumentoJpaController tipoDocumentoJpa;
    @Inject
    private TipoEmpleadoJpaController tipoEmpleadoJpa;
    @Inject
    private TipoCompaniaJpaController companiaInternaJpa;
    @Inject
    private CiudadJpaController ciudadJpa;
    @Inject
    private AplicacionJpaController aplicacionJpa;
    @Inject
    private GerenciaJpaController gerenciaJpa;
    @Inject
    private CargoJpaController cargoJpa;
    @Inject
    private CoordinacionJpaController coordinacionJpa;
    @Inject
    private UsuarioJpaController usuarioJpa;
    @Inject
    private SolicitudJpaController solicitudJpa;
    @Inject
    private TipoUsuarioJpaController tipoUsuarioJpa;
    @Inject
    private PrivilegioSolicitudJpaController privilegioJpa;
    @Inject
    private PerfilJpaController perfilJpa;
    @Inject
    private ParametrosPasswordJpaController parametrosPasswordJpa;
    @Inject
    private UsuariosPorAplicacionesJpaController usuarioPorAplicacionesJpa;
    @Inject
    private CertificacionUsuarioJpaController certificacionUsuarioJpa;
    @Inject
    private UsuarioTemporalJpaController usuarioTemporalJpa;

    //--------------------------------------------------------------------------
    // UsuarioTemporal
    //--------------------------------------------------------------------------
    @Override
    public void crearUsuarioTemporal(UsuarioTemporal usuarioTemporal) throws ClaroException {
        try {
            usuarioTemporalJpa.create(usuarioTemporal);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando el usuario temporal. | EJBADatabaseSolucitudes | crearUsuarioTemporal -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarUsuarioTemporal(UsuarioTemporal usuarioTemporal) throws ClaroException {
        try {
            usuarioTemporalJpa.edit(usuarioTemporal);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando el usuario temporal. | EJBADatabaseSolucitudes | modificarUsuarioTemporal -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoUsuarioTemporal(UsuarioTemporal usuarioTemporal) throws ClaroException {
        try {
            usuarioTemporalJpa.borradoLogicoUsuarioTemporal(usuarioTemporal);
        } catch (Exception ex) {
            throw new ClaroException("Error borrando el usuario temporal. | EJBADatabaseSolucitudes | borradoLogicoUsuarioTemporal -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public UsuarioTemporal findUsuarioTemporalByIdUsuarioSolicitante(Integer idSolicitante) {
        return usuarioTemporalJpa.findUsuarioTemporalByIdUsuario(idSolicitante);
    }

    //--------------------------------------------------------------------------
    //Usuario
    //--------------------------------------------------------------------------
    @Override
    public void crearUsuario(Usuario usuario) throws ClaroException {
        try {
            usuarioJpa.create(usuario);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando el usuario. | EJBADatabaseSolucitudes | crearSolicitud -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando el usuario. | EJBADatabaseSolucitudes | crearSolicitud -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarUsuario(Usuario usuario) throws ClaroException {
        try {
            usuarioJpa.edit(usuario);
        } catch (NonexistentEntityException ex) {
            throw new ClaroException("Error modificando el usuario. | EJBADatabaseSolucitudes | modificaUsuario -> " + ex.getMessage(), ex);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando el usuario. | EJBADatabaseSolucitudes | modificaUsuario -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando el usuario. | EJBADatabaseSolucitudes | modificaUsuario -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoUsuario(Usuario usuario) throws ClaroException {
        try {
            usuarioJpa.borradoLogicoUsuario(usuario);
        } catch (NonexistentEntityException ex) {
            throw new ClaroException("Error borrando el usuario. | EJBADatabaseSolucitudes | borradoLogicoUsuario -> " + ex.getMessage(), ex);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error borrando el usuario. | EJBADatabaseSolucitudes | borradoLogicoUsuario -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error borrando el usuario. | EJBADatabaseSolucitudes | borradoLogicoUsuario -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<Usuario> findUsuarios(int firstResult, int maxResults) {
        return usuarioJpa.findUsuariosPaginacion(maxResults, firstResult);
    }

    @Override
    public List<Usuario> findUsuarioByUsername(String username) {
        return usuarioJpa.findUsuariosByUsername(username, EstadoActividadEnum.ACTIVO.getId(), EstadoActividadEnum.ACTIVO.getId());
    }

    @Override
    public List<Usuario> findUsuarioByGerenciaAndGrupo(short idGerencia, short idEjecutor, short idAdministrador, Short activo) {
        return usuarioJpa.findUsuarioByGerenciaAndGrupo(idGerencia, idEjecutor, idAdministrador, activo);
    }

    @Override
    public List<Usuario> findUsuarioByGerencia(short idGerencia, Short activo) {
        return usuarioJpa.findUsuarioByGerencia(idGerencia, activo);
    }

    @Override
    public Usuario findUsuarioById(int idUsuario) {
        return usuarioJpa.findUsuarioActivo(idUsuario);
    }

    @Override
    public Usuario findUsuarioByNumeroDocumento(long numeroDocumento) {
        return usuarioJpa.findUsuarioByNumeroDocumento(numeroDocumento, EstadoActividadEnum.ACTIVO.getId());
    }

    @Override
    public int countAllUsuarios() {
        return usuarioJpa.getUsuarioCount();
    }

    @Override
    public List<Usuario> findUsuarioByGerenciaAndUsername(short idGerencia, String username, Short activo) {
        return usuarioJpa.findUsuariosByGerenciaAndUsername(idGerencia, username, activo);
    }

    @Override
    public Usuario findUsuarioByGerenciaAndNumeroDocumento(short idGerencia, Long numeroDocumento, Short activo) {
        return usuarioJpa.findUsuarioByGerenciaAndNumeroDocumento(idGerencia, numeroDocumento, activo);
    }

    @Override
    public List<Usuario> findUsuariosByNombre(String nombres) {
        return usuarioJpa.findUsuariosByNombre(nombres);
    }

    @Override
    public List<Usuario> findUsuariosByApellido(String apellidos) {
        return usuarioJpa.findUsuariosByApellido(apellidos);
    }

    @Override
    public int countUsuariosQuery(UsuarioDto dataTransfer) {
        return usuarioJpa.getUsuarioCount(dataTransfer);
    }

    @Override
    public List<Usuario> findUsuarios(UsuarioDto dataTransfer) {
        return usuarioJpa.findUsuariosNoPaginacion(dataTransfer);
    }

    @Override
    public List<Usuario> findUsuarios(int firstResult, int maxResults, UsuarioDto dataTransfer) {
        return usuarioJpa.findUsuariosPaginacion(firstResult, maxResults, dataTransfer);
    }

    @Override
    public List<Usuario> findUsuariosByGrupo(Short idGrupo, String sortCol, boolean asc) {
        return usuarioJpa.findUsuariosByGrupo(idGrupo, sortCol, asc);
    }

    @Override
    public Usuario findUsuarioByUsernameExacto(String username) {
        return usuarioJpa.findUsuarioByUsernameExacto(username, EstadoActividadEnum.ACTIVO.getId(), EstadoActividadEnum.ACTIVO.getId());
    }

    //--------------------------------------------------------------------------
    //Solicitud
    //--------------------------------------------------------------------------
    @Override
    public void crearSolicitud(Solicitud solicitud) throws ClaroException {
        try {
            solicitudJpa.create(solicitud);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando la solicitud. | EJBADatabaseSolucitudes | crearSolicitud -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando la solicitud. | EJBADatabaseSolucitudes | crearSolicitud -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public Solicitud modificarSolicitud(Solicitud solicitud) throws ClaroException {
        try {
            return solicitudJpa.edit(solicitud);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando la solicitud. | EJBADatabaseSolucitudes | modificarSolicitud -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando la solicitud. | EJBADatabaseSolucitudes | modificarSolicitud -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void insertarSolicitudesMasivas(List<Solicitud> solicitudes) throws ClaroException {

        try {
            if (solicitudes != null) {
                solicitudJpa.insertarSolicitudesMasivas(solicitudes);
            }
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error enviando solciitudes masivas. | EJBADatabaseSolucitudes | insertarSolicitudesMasivas -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error enviando solciitudes masivas. | EJBADatabaseSolucitudes | insertarSolicitudesMasivas -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<Solicitud> findSolicitudes(SolicitudDto dataTransfer) {
        return solicitudJpa.findSolicitudesNoPaginacion(dataTransfer);
    }

    @Override
    public List<Solicitud> findSolicitudes(int firstResult, int maxResults, SolicitudDto dataTransfer) {
        return solicitudJpa.findSolicitudesPaginacion(firstResult, maxResults, dataTransfer);
    }

    @Override
    public Solicitud findSolicitudById(Long idSolicitud) {
        return solicitudJpa.findSolicitud(idSolicitud);
    }

    @Override
    public int countAllSolicitudes() {
        return solicitudJpa.getSolicitudCount();
    }

    @Override
    public List<Solicitud> findSolicitudByEjecutor(Integer idEjecutor, short idEstado) {
        List<Solicitud> solicitudes;
        solicitudes = solicitudJpa.findSolicitudByEjecutor(idEjecutor, idEstado);
        return solicitudes;
    }

    @Override
    public List<Solicitud> findSolicitudByGerenciaAsignadoraAndEstado(Short idGerencia, short idEstado) {
        List<Solicitud> solicitudes;
        solicitudes = solicitudJpa.findSolicitudByGerenciaAsignadoraAndEstado(idGerencia, idEstado);
        return solicitudes;
    }

    @Override
    public List<Solicitud> findSolicitudByGerenciaAprobadoraAndEstado(Short idGerencia, short idEstado) {
        List<Solicitud> solicitudes;
        solicitudes = solicitudJpa.findSolicitudByGerenciaAprobadoraAndEstado(idGerencia, idEstado);
        return solicitudes;
    }

    @Override
    public Solicitud findSolicitudByIdSolicitudAndGerencia(Long id, Short idGerencia) {
        return solicitudJpa.findSolicitudByIdSolicitudAndGerencia(id, idGerencia);
    }

    @Override
    public List<Solicitud> findSolicitudByGerencia(short idGerencia) {
        List<Solicitud> solicitudes;
        solicitudes = solicitudJpa.findSolicitudByGerencia(idGerencia);
        return solicitudes;
    }

    @Override
    public Solicitud findSolicitudByIdSolicitudAndGerenciaAprobadora(Long id, Short idGerencia) {
        return solicitudJpa.findSolicitudByIdSolicitudAndGerenciaAprobadora(id, idGerencia);
    }

    @Override
    public Solicitud findSolicitudByIdSolicitudAndGerenciaAsignadora(Long id, Short idGerencia) {
        return solicitudJpa.findSolicitudByIdSolicitudAndGerenciaAsignadora(id, idGerencia);
    }

    @Override
    public List<Solicitud> findSolicitudBySolicitante(Integer idSolicitante, short idEstado) {
        List<Solicitud> solicitudes;
        solicitudes = solicitudJpa.findSolicitudBySolicitante(idSolicitante, idEstado);
        return solicitudes;
    }

    @Override
    public List<Solicitud> findSolicitudes(int paginaInicio, int maxResultados) {
        List<Solicitud> solicitudes;
        solicitudes = solicitudJpa.findSolicitudesPaginacion(maxResultados, paginaInicio);
        return solicitudes;
    }

    @Override
    public List<Solicitud> findSolicitudByIdSolicitanteEstadosAccion(Integer idSolicitante, Short accion, List<EstadosSolicitudEnum> estados) {
        return solicitudJpa.findSolicitudByIdSolicitanteEstadosAccion(idSolicitante, accion, estados);
    }

    @Override
    public int countSolicitudesByAplicacionAccionPerfilEstados(Integer idAplicacion, short accion, Integer idPerfil, List<EstadosSolicitudEnum> estados) {
        return solicitudJpa.countByAplicacionAccionPerfilEstados(idAplicacion, accion, idPerfil, estados);
    }

    @Override
    public int countSolicitudesQuery(SolicitudDto dataTransfer) {
        return solicitudJpa.getSolicitudCount(dataTransfer);
    }

    @Override
    public void clearAndFlushSolicitudes() {
        solicitudJpa.clearAndFlush();
    }

    //--------------------------------------------------------------------------
    // CertificacionUsuario
    //--------------------------------------------------------------------------
    @Override
    public void crearCertificacionUsuario(CertificacionUsuario certificacionUsuario) throws ClaroException {
        try {
            certificacionUsuarioJpa.create(certificacionUsuario);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando la certificacion. | EJBADatabaseSolucitudes | crearCertificacionUsuario -> " + ex.getMessage(), ex);
        }
    }

    //--------------------------------------------------------------------------
    //ParametrosPassword
    //--------------------------------------------------------------------------
    @Override
    public List<ParametrosPassword> findAllParametrosPasswordEntities() {
        return parametrosPasswordJpa.findAllParametrosPasswordEntities();
    }

    @Override
    public List<ParametrosPassword> findParametrosPasswordEntities(int maxResults, int firstResult) {
        return parametrosPasswordJpa.findParametrosPasswordEntities(maxResults, firstResult);
    }

    @Override
    public ParametrosPassword findParametrosPassword(Short id) {
        return parametrosPasswordJpa.findParametrosPassword(id);
    }

    //--------------------------------------------------------------------------
    //Perfil
    //--------------------------------------------------------------------------
    @Override
    public void crearPerfil(Perfil perfil) throws ClaroException {
        try {
            perfilJpa.create(perfil);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando el perfil. | EJBADatabaseSolucitudes | crearPerfil -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando el perfil. | EJBADatabaseSolucitudes | crearPerfil -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarPerfil(Perfil perfil) throws ClaroException {
        try {
            perfilJpa.edit(perfil);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando el perfil. | EJBADatabaseSolucitudes | modificarPerfil -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando el perfil. | EJBADatabaseSolucitudes | modificarPerfil -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoPerfil(Perfil perfil) throws ClaroException {
        try {
            perfilJpa.borradoLogico(perfil);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando el perfil. | EJBADatabaseSolucitudes | borradoLogicoPerfil -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando el perfil. | EJBADatabaseSolucitudes | borradoLogicoPerfil -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<Perfil> findPerfilByEstado(Short estado) {
        List<Perfil> perfiles;
        perfiles = perfilJpa.findPerfilByEstado(estado);
        return perfiles;
    }

    //--------------------------------------------------------------------------
    //Empresa
    //--------------------------------------------------------------------------
    @Override
    public void crearEmpresa(Empresa empresa) throws ClaroException {
        try {
            empresaJpa.create(empresa);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando la empresa. | EJBADatabaseSolucitudes | crearEmpresa -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando la empresa. | EJBADatabaseSolucitudes | crearEmpresa -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarEmpresa(Empresa empresa) throws ClaroException {
        try {
            empresaJpa.edit(empresa);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando la empresa. | EJBADatabaseSolucitudes | modificarEmpresa -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando la empresa. | EJBADatabaseSolucitudes | modificarEmpresa -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoEmpresa(Empresa empresa) throws ClaroException {
        try {
            empresaJpa.borradoLogico(empresa);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando la empresa. | EJBADatabaseSolucitudes | borradoLogicoEmpresa -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando la empresa. | EJBADatabaseSolucitudes | borradoLogicoEmpresa -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<Empresa> findEmpresaByEstado(Short estado) {
        List<Empresa> empresas;
        empresas = empresaJpa.findEmpresaByEstado(estado);
        return empresas;
    }

    //--------------------------------------------------------------------------
    //TipoAplicacion
    //--------------------------------------------------------------------------
    @Override
    public void crearTipoAplicacion(TipoAplicacion tipoAplicacion) throws ClaroException {
        try {
            tipoAplicacionJpa.create(tipoAplicacion);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando tipo aplicación. | EJBADatabaseSolucitudes | crearTipoAplicacion -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando tipo aplicación. | EJBADatabaseSolucitudes | crearTipoAplicacion -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarTipoAplicacion(TipoAplicacion tipoAplicacion) throws ClaroException {
        try {
            tipoAplicacionJpa.edit(tipoAplicacion);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando tipo aplicación. | EJBADatabaseSolucitudes | modificarTipoAplicacion -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando tipo aplicación. | EJBADatabaseSolucitudes | modificarTipoAplicacion -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoTipoAplicacion(TipoAplicacion tipoAplicacion) throws ClaroException {
        try {
            tipoAplicacionJpa.borradoLogico(tipoAplicacion);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando tipo aplicación. | EJBAdminSolicitudes | borradoLogicoTipoAplicacion -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando tipo aplicación. | EJBAdminSolicitudes | borradoLogicoTipoAplicacion -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<TipoAplicacion> findTipoAplicacionByEstado(Short estado) {
        List<TipoAplicacion> tiposAplicacion;
        tiposAplicacion = tipoAplicacionJpa.findTipoAplicacionByEstado(estado);
        return tiposAplicacion;
    }

    //--------------------------------------------------------------------------
    //TipoEmpleado
    //--------------------------------------------------------------------------
    @Override
    public void crearTipoEmpleado(TipoEmpleado tipoEmpleado) throws ClaroException {
        try {
            tipoEmpleadoJpa.create(tipoEmpleado);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando tipo empleado. | EJBADatabaseSolucitudes | crearTipoEmpleado -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando tipo empleado. | EJBADatabaseSolucitudes | crearTipoEmpleado -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarTipoEmpleado(TipoEmpleado tipoEmpleado) throws ClaroException {
        try {
            tipoEmpleadoJpa.edit(tipoEmpleado);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando tipo empleado. | EJBADatabaseSolucitudes | modificarTipoEmpleado -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando tipo empleado. | EJBADatabaseSolucitudes | modificarTipoEmpleado -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoTipoEmpleado(TipoEmpleado tipoEmpleado) throws ClaroException {
        try {
            tipoEmpleadoJpa.borradoLogico(tipoEmpleado);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando tipo empleado. | EJBADatabaseSolucitudes | borradoLogicoTipoEmpleado -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando tipo empleado. | EJBADatabaseSolucitudes | borradoLogicoTipoEmpleado -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<TipoEmpleado> findTipoEmpleadoByEstado(Short estado) {
        List<TipoEmpleado> tiposEmpelados;
        tiposEmpelados = tipoEmpleadoJpa.findTipoEmpleadoByEstado(estado);
        return tiposEmpelados;
    }

    //--------------------------------------------------------------------------
    //TipoDocumento
    //--------------------------------------------------------------------------
    @Override
    public void crearTipoDocumento(TipoDocumento tipoDocumento) throws ClaroException {
        try {
            tipoDocumentoJpa.create(tipoDocumento);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando tipo documento. | EJBADatabaseSolucitudes | crearTipoDocumento -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando tipo documento. | EJBADatabaseSolucitudes | crearTipoDocumento -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarTipoDocumento(TipoDocumento tipoDocumento) throws ClaroException {
        try {
            tipoDocumentoJpa.edit(tipoDocumento);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando el tipo documento. | EJBADatabaseSolucitudes | modificarTipoDocumento -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando el tipo documento. | EJBADatabaseSolucitudes | modificarTipoDocumento -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoTipoDocumento(TipoDocumento tipoDocumento) throws ClaroException {
        try {
            tipoDocumentoJpa.borradoLogico(tipoDocumento);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando el tipo documento. | EJBADatabaseSolucitudes | borradoLogicoTipoDocumento -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando el tipo documento. | EJBADatabaseSolucitudes | borradoLogicoTipoDocumento -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<TipoDocumento> findTipoDocumentoByEstado(Short estado) {
        List<TipoDocumento> tiposDocumento;
        tiposDocumento = tipoDocumentoJpa.findTipoDocumentoByEstado(estado);
        return tiposDocumento;
    }

    //--------------------------------------------------------------------------
    //TipoCompañia
    //--------------------------------------------------------------------------
    @Override
    public void crearTipoCompania(TipoCompania tipoCompania) throws ClaroException {
        try {
            companiaInternaJpa.create(tipoCompania);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando la compania interna. | EJBADatabaseSolucitudes | crearCompaniaInterna -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando el compania interna. | EJBADatabaseSolucitudes | crearCompaniaInterna -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarTipoCompania(TipoCompania tipoCompania) throws ClaroException {
        try {
            companiaInternaJpa.edit(tipoCompania);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando la compania interna. | EJBADatabaseSolucitudes | modificarCompaniaInterna -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando el compania interna. | EJBADatabaseSolucitudes | modificarCompaniaInterna -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoTipoCompania(TipoCompania tipoCompania) throws ClaroException {
        try {
            companiaInternaJpa.borradoLogico(tipoCompania);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando la compania interna. | EJBADatabaseSolucitudes | borradoLogicoTipoCompania -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando el compania interna. | EJBADatabaseSolucitudes | borradoLogicoTipoCompania -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<TipoCompania> findTipoCompaniaByEstado(Short estado) {
        List<TipoCompania> companiasInternas;
        companiasInternas = companiaInternaJpa.findTipoCompaniaByEstado(estado);
        return companiasInternas;
    }

    //--------------------------------------------------------------------------
    //TipoUsuarios
    //--------------------------------------------------------------------------
    @Override
    public List<TipoUsuario> findTipoUsuarios() {
        return tipoUsuarioJpa.findTipoUsuarioEntities();
    }

    //--------------------------------------------------------------------------
    //Ciudad
    //--------------------------------------------------------------------------
    @Override
    public void crearCiudad(Ciudad ciudad) throws ClaroException {
        try {
            ciudadJpa.create(ciudad);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando la ciudad. | EJBADatabaseSolucitudes | crearCiudad -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando la ciudad. | EJBADatabaseSolucitudes | crearCiudad -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarCiudad(Ciudad ciudad) throws ClaroException {
        try {
            ciudadJpa.edit(ciudad);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando la ciudad. | EJBADatabaseSolucitudes | modificarCiudad -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando la ciudad. | EJBADatabaseSolucitudes | modificarCiudad -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoCiudad(Ciudad ciudad) throws ClaroException {
        try {
            ciudadJpa.borradoLogico(ciudad);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando la ciudad. | EJBADatabaseSolucitudes | borradoLogicoCiudad -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando la ciudad. | EJBADatabaseSolucitudes | borradoLogicoCiudad -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<Ciudad> findCiudadByEstado(Short estado) {
        List<Ciudad> ciudades;
        ciudades = ciudadJpa.findCiudadByEstado(estado);
        return ciudades;
    }

    //--------------------------------------------------------------------------
    //Aplicacion
    //--------------------------------------------------------------------------
    @Override
    public void crearAplicacion(Aplicacion aplicacion) throws ClaroException {
        try {
            aplicacionJpa.create(aplicacion);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando la aplicación. | EJBADatabaseSolucitudes | crearAplicacion -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando la aplicación. | EJBADatabaseSolucitudes | crearAplicacion -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarAplicacion(Aplicacion aplicacion) throws ClaroException {
        try {
            aplicacionJpa.edit(aplicacion);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando la aplicación. | EJBADatabaseSolucitudes | modificarAplicacion -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando la aplicación. | EJBADatabaseSolucitudes | modificarAplicacion -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoAplicacion(Aplicacion aplicacion) throws ClaroException {
        try {
            aplicacionJpa.borradoLogico(aplicacion);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando la aplicación. | EJBADatabaseSolucitudes | borradoLogicoAplicacion -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando la aplicación. | EJBADatabaseSolucitudes | borradoLogicoAplicacion -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public Aplicacion findAplicacion(int id) {
        return aplicacionJpa.findAplicacion(id);
    }

    @Override
    public List<Aplicacion> findAplicacionByEstado(Short estado) {
        return aplicacionJpa.findAplicacionByEstado(estado);
    }

    @Override
    public Integer countAplicacionByNombreTipoEstado(String nombre, Integer tipoAplicacion, Short estado) {
        return aplicacionJpa.findAplicacionByNombreTipoEstado(nombre, tipoAplicacion, estado);
    }

    //--------------------------------------------------------------------------
    //Gerencia
    //--------------------------------------------------------------------------
    @Override
    public void crearGerencia(Gerencia gerencia) throws ClaroException {
        try {
            gerenciaJpa.create(gerencia);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando la gerencia. | EJBADatabaseSolucitudes | crearGerencia -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando la gerencia. | EJBADatabaseSolucitudes | crearGerencia -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarGerencia(Gerencia gerencia) throws ClaroException {
        try {
            gerenciaJpa.edit(gerencia);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando la gerencia. | EJBADatabaseSolucitudes | modificarGerencia -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando la gerencia. | EJBADatabaseSolucitudes | modificarGerencia -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoGerencia(Gerencia gerencia) throws ClaroException {
        try {
            gerenciaJpa.borradoLogico(gerencia);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando la gerencia. | EJBADatabaseSolucitudes | borradoLogicoGerencia -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando la gerencia. | EJBADatabaseSolucitudes | borradoLogicoGerencia -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<Gerencia> findGerenciaByEstado(Short estado) {
        return gerenciaJpa.findGerenciaByEstado(estado);
    }

    @Override
    public Gerencia findGerenciaById(Short idGerencia) {
        return gerenciaJpa.findGerencia(idGerencia);
    }

    //--------------------------------------------------------------------------
    //Cargo
    //--------------------------------------------------------------------------
    @Override
    public void crearCargo(Cargo cargo) throws ClaroException {
        try {
            cargoJpa.create(cargo);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando el cargo. | EJBADatabaseSolucitudes | crearCargo -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando el cargo. | EJBADatabaseSolucitudes | crearCargo -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarCargo(Cargo cargo) throws ClaroException {
        try {
            cargoJpa.edit(cargo);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando el cargo. | EJBADatabaseSolucitudes | modificarCargo -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando el cargo. | EJBADatabaseSolucitudes | modificarCargo -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoCargo(Cargo cargo) throws ClaroException {
        try {
            cargoJpa.borradoLogico(cargo);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando el cargo. | EJBADatabaseSolucitudes | borradoLogicoCargo -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando el cargo. | EJBADatabaseSolucitudes | borradoLogicoCargo -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<Cargo> findCargoByEstado(Short estado) {
        List<Cargo> cargos;
        cargos = cargoJpa.findCargoByEstado(estado);
        return cargos;
    }

    //--------------------------------------------------------------------------
    //Coordinacion
    //--------------------------------------------------------------------------
    @Override
    public void crearCoordinacion(Coordinacion coordinacion) throws ClaroException {
        try {
            coordinacionJpa.create(coordinacion);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando la coordinación. | EJBADatabaseSolucitudes | crearCoordinacion -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando la coordinación. | EJBADatabaseSolucitudes | crearCoordinacion -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarCoordinacion(Coordinacion coordinacion) throws ClaroException {
        try {
            coordinacionJpa.edit(coordinacion);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando la coordinación. | EJBADatabaseSolucitudes | modificarCoordinacion -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando la coordinación. | EJBADatabaseSolucitudes | modificarCoordinacion -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoCoordinacion(Coordinacion coordinacion) throws ClaroException {
        try {
            coordinacionJpa.borradoLogico(coordinacion);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando la coordinación. | EJBADatabaseSolucitudes | borradoLogicoCoordinacion -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando la coordinación. | EJBADatabaseSolucitudes | borradoLogicoCoordinacion -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<Coordinacion> findCoordinacionByEstado(Short estado) {
        List<Coordinacion> coordinaciones;
        coordinaciones = coordinacionJpa.findCoordinacionByEstado(estado);
        return coordinaciones;
    }

    //--------------------------------------------------------------------------
    //PrivilegioSolicitud
    //--------------------------------------------------------------------------
    @Override
    public void crearPrivilegioSolicitud(PrivilegioSolicitud privilegio) throws ClaroException {
        try {
            privilegioJpa.create(privilegio);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando los privilegios por solicitud. | EJBADatabaseSolucitudes | crearPrivilegioSolicitud -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando los privilegios por solicitud. | EJBADatabaseSolucitudes | crearPrivilegioSolicitud -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void modificarPrivilegioSolicitud(PrivilegioSolicitud privilegioSolicitud) throws ClaroException {
        try {
            privilegioJpa.edit(privilegioSolicitud);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error modificando el privilegio. | EJBADatabaseSolucitudes | modificarPrivilegioSolicitud -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error modificando el privilegio. | EJBADatabaseSolucitudes | modificarPrivilegioSolicitud -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public void borradoLogicoPrivilegioSolicitud(PrivilegioSolicitud privilegioSolicitud) throws ClaroException {
        try {
            privilegioJpa.borradoLogico(privilegioSolicitud);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error eliminando el privilegio. | EJBADatabaseSolucitudes | borradoLogicoPrivilegioSolicitud -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error eliminando el privilegio. | EJBADatabaseSolucitudes | borradoLogicoPrivilegioSolicitud -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public PrivilegioSolicitud findPrivilegioSolicitud(int idPrivilegio) {
        return privilegioJpa.findPrivilegioSolicitud(idPrivilegio);
    }

    @Override
    public List<PrivilegioSolicitud> findPrivilegioByAplicacionGerencia(int idAplicacion, int idGerencia) {
        return privilegioJpa.findByAplicacionGerencia(idAplicacion, idGerencia);
    }

    @Override
    public List<PrivilegioSolicitud> findPrivilegioByGerencia(short idGerencia) {
        return privilegioJpa.findByGerencia(idGerencia);
    }

    @Override
    public PrivilegioSolicitud findPrivilegioByAplicacionPerfilGerencia(int idAplicacion, int idPerfil, int idGerencia) {
        return privilegioJpa.findByAplicacionPerfilGerencia(idAplicacion, idPerfil, idGerencia);
    }

    @Override
    public List<PrivilegioSolicitud> findPrivilegioByAplicacion(int idAplicacion) {
        return privilegioJpa.findPrivilegioByAplicacion(idAplicacion);
    }

    @Override
    public int countAllPrivilegioSolicitudes() {
        return privilegioJpa.getPrivilegioSolicitudCount();
    }

    @Override
    public int countPrivilegioByAplicacionGerenciaPerfil(int idAplicacion, int idGerenciaAprobadora, int idPerfil, Short activo) {
        return privilegioJpa.countByAplicacionGerenciaPerfil(idAplicacion, idGerenciaAprobadora, idPerfil, activo);
    }

    @Override
    public int countPrivilegiosQuery(PrivilegioSolicitudDto dataTransfer) {
        return privilegioJpa.getPrivilegioCount(dataTransfer);
    }

    @Override
    public List<PrivilegioSolicitud> findPrivilegios(PrivilegioSolicitudDto dataTransfer) {
        return privilegioJpa.findPrivilegiosNoPaginacion(dataTransfer);
    }

    @Override
    public List<PrivilegioSolicitud> findPrivilegios(int firstResult, int maxResults, PrivilegioSolicitudDto dataTransfer) {
        return privilegioJpa.findPrivilegiosPaginacion(firstResult, maxResults, dataTransfer);
    }

    //--------------------------------------------------------------------------
    //UsuarioPorAplicacion
    //--------------------------------------------------------------------------
    @Override
    public void crearUsuarioPorAplicaciones(UsuariosPorAplicaciones usrxapps) throws ClaroException {
        try {
            usuarioPorAplicacionesJpa.create(usrxapps);
        } catch (RollbackFailureException ex) {
            throw new ClaroException("Error insertando los usuarios x aplicaciones. | EJBADatabaseSolucitudes | crearUsuarioxAplicaciones -> " + ex.getMessage(), ex);
        } catch (Exception ex) {
            throw new ClaroException("Error insertando los usuarios x aplicaciones. | EJBADatabaseSolucitudes | crearUsuarioxAplicaciones -> " + ex.getMessage(), ex);
        }
    }

    @Override
    public List<UsuariosPorAplicaciones> findAplicacionesByUsuario(Integer idUsuario) {
        return usuarioPorAplicacionesJpa.findAplicacionesByUsuario(idUsuario);
    }

    @Override
    public List<UsuariosPorAplicaciones> findAplicacionesActivoByUsuario(Short activo, Integer idUsuario) {
        return usuarioPorAplicacionesJpa.findAplicacionesActivoByUsuario(activo, idUsuario);
    }

    @Override
    public int countUsuarioFijoByIdUsuario(Integer idSolicitante, Integer idAplicacion) {
        return usuarioPorAplicacionesJpa.countUsuarioFijoByIdUsuario(idSolicitante, idAplicacion);
    }

    @Override
    public UsuariosPorAplicaciones findUsuarioPorAplicaciones(Integer idUsuarioAplicacion) {
        return usuarioPorAplicacionesJpa.findUsuariosPorAplicaciones(idUsuarioAplicacion, EstadoActividadEnum.ACTIVO.getId());
    }

}
